/**
 * 城市工具函数
 * 用于根据用户经纬度判断所在城市
 */

import guangzhouData from '../components/city-select/guangzhou.json';
import dongguanData from '../components/city-select/dongguan.json';

/**
 * 城市数据配置
 */
const CITY_DATA = {
  guangzhou: {
    name: '广州市',
    code: '020',
    adcode: '440100',
    data: guangzhouData
  },
  dongguan: {
    name: '东莞市',
    code: '0769', 
    adcode: '441900',
    data: dongguanData
  }
};

/**
 * 解析polyline字符串为坐标点数组
 * @param {string} polyline - polyline字符串，格式为"lng1,lat1;lng2,lat2;..."
 * @returns {Array} 坐标点数组 [[lng1, lat1], [lng2, lat2], ...]
 */
function parsePolyline(polyline) {
  if (!polyline || typeof polyline !== 'string') {
    return [];
  }
  
  try {
    return polyline.split(';').map(point => {
      const [lng, lat] = point.split(',').map(Number);
      return [lng, lat];
    }).filter(point => point.length === 2 && !isNaN(point[0]) && !isNaN(point[1]));
  } catch (error) {
    console.error('解析polyline失败:', error);
    return [];
  }
}

/**
 * 判断点是否在多边形内部（射线法）
 * @param {Array} point - 点坐标 [lng, lat]
 * @param {Array} polygon - 多边形坐标数组 [[lng1, lat1], [lng2, lat2], ...]
 * @returns {boolean} 是否在多边形内部
 */
function isPointInPolygon(point, polygon) {
  if (!point || !polygon || polygon.length < 3) {
    return false;
  }
  
  const [x, y] = point;
  let inside = false;
  
  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
    const [xi, yi] = polygon[i];
    const [xj, yj] = polygon[j];
    
    if (((yi > y) !== (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi)) {
      inside = !inside;
    }
  }
  
  return inside;
}

/**
 * 根据经纬度判断用户所在城市
 * @param {number} longitude - 经度
 * @param {number} latitude - 纬度
 * @returns {Object|null} 城市信息对象或null
 */
export function detectCityByLocation(longitude, latitude) {
  if (!longitude || !latitude || isNaN(longitude) || isNaN(latitude)) {
    console.warn('无效的经纬度参数:', { longitude, latitude });
    return null;
  }
  
  const userPoint = [longitude, latitude];
  
  // 遍历所有城市数据
  for (const [cityKey, cityInfo] of Object.entries(CITY_DATA)) {
    try {
      const districts = cityInfo.data.districts;
      
      if (!districts || !Array.isArray(districts)) {
        continue;
      }
      
      // 检查每个区域的polyline
      for (const district of districts) {
        if (!district.polyline) {
          continue;
        }
        
        // polyline可能包含多个区域，用|分隔
        const polylineSegments = district.polyline.split('|');
        
        for (const segment of polylineSegments) {
          const polygon = parsePolyline(segment);
          
          if (polygon.length >= 3 && isPointInPolygon(userPoint, polygon)) {
            return {
              key: cityKey,
              name: cityInfo.name,
              code: cityInfo.code,
              adcode: cityInfo.adcode,
              district: district.name
            };
          }
        }
      }
    } catch (error) {
      console.error(`检测城市 ${cityKey} 时出错:`, error);
    }
  }
  
  return null;
}

/**
 * 获取所有支持的城市列表
 * @returns {Array} 城市列表
 */
export function getSupportedCities() {
  return Object.entries(CITY_DATA).map(([key, info]) => ({
    key,
    name: info.name,
    code: info.code,
    adcode: info.adcode
  }));
}

/**
 * 根据城市key获取城市信息
 * @param {string} cityKey - 城市key
 * @returns {Object|null} 城市信息
 */
export function getCityInfo(cityKey) {
  const cityInfo = CITY_DATA[cityKey];
  if (!cityInfo) {
    return null;
  }
  
  return {
    key: cityKey,
    name: cityInfo.name,
    code: cityInfo.code,
    adcode: cityInfo.adcode
  };
}

/**
 * 获取用户当前位置
 * @returns {Promise} 返回位置信息的Promise
 */
export function getCurrentLocation() {
  return new Promise((resolve, reject) => {
    uni.getLocation({
      type: 'gcj02', // 使用国测局坐标系
      success: (res) => {
        console.log('获取位置成功:', res);
        resolve({
          longitude: res.longitude,
          latitude: res.latitude,
          accuracy: res.accuracy,
          address: res.address
        });
      },
      fail: (err) => {
        console.error('获取位置失败:', err);
        reject(err);
      }
    });
  });
}

/**
 * 存储当前选中的城市
 * @param {Object} cityInfo - 城市信息
 */
export function saveCurrentCity(cityInfo) {
  try {
    uni.setStorageSync('currentCity', cityInfo);
    console.log('城市信息已保存:', cityInfo);
  } catch (error) {
    console.error('保存城市信息失败:', error);
  }
}

/**
 * 获取当前选中的城市
 * @returns {Object|null} 城市信息
 */
export function getCurrentCity() {
  try {
    const cityInfo = uni.getStorageSync('currentCity');
    return cityInfo || null;
  } catch (error) {
    console.error('获取城市信息失败:', error);
    return null;
  }
}

/**
 * 自动检测并设置当前城市
 * @returns {Promise} 返回检测结果的Promise
 */
export async function autoDetectAndSetCity() {
  try {
    // 首先尝试从存储中获取已保存的城市
    const savedCity = getCurrentCity();
    if (savedCity) {
      console.log('使用已保存的城市:', savedCity);
      return savedCity;
    }
    
    // 获取用户位置
    const location = await getCurrentLocation();
    
    // 根据位置检测城市
    const detectedCity = detectCityByLocation(location.longitude, location.latitude);
    
    if (detectedCity) {
      // 保存检测到的城市
      saveCurrentCity(detectedCity);
      console.log('自动检测到城市:', detectedCity);
      return detectedCity;
    } else {
      // 如果检测不到，使用默认城市（东莞）
      const defaultCity = getCityInfo('dongguan');
      saveCurrentCity(defaultCity);
      console.log('使用默认城市:', defaultCity);
      return defaultCity;
    }
  } catch (error) {
    console.error('自动检测城市失败:', error);
    // 出错时使用默认城市
    const defaultCity = getCityInfo('dongguan');
    saveCurrentCity(defaultCity);
    return defaultCity;
  }
}